/*
 * Copyright (C) 2013 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package app.softtech.freechat.gcm;

import java.util.ArrayList;
import java.util.List;

import org.apache.http.NameValuePair;
import org.apache.http.message.BasicNameValuePair;
import org.json.JSONException;
import org.json.JSONObject;

import android.app.IntentService;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.SystemClock;
import android.support.v4.app.NotificationCompat;
import android.util.Log;
import app.softtech.freechat.ActivityRegister;
import app.softtech.freechat.Constants;
import app.softtech.freechat.HttpRequest;
import app.softtech.freechat.R;
import app.softtech.freechat.database.DatabaseFriend;
import app.softtech.freechat.database.DatabaseHanler;

import com.google.android.gms.gcm.GoogleCloudMessaging;

/**
 * This {@code IntentService} does the actual handling of the GCM message. {@code GcmBroadcastReceiver} (a {@code WakefulBroadcastReceiver}) holds a partial wake lock for this service while the
 * service does its work. When the service is finished, it calls {@code completeWakefulIntent()} to release the wake lock.
 */
public class GcmIntentService extends IntentService {
	public static final int NOTIFICATION_ID = 1;
	private NotificationManager mNotificationManager;
	NotificationCompat.Builder builder;

	private String mUserId, mUserRequestId, mId_request;

	public GcmIntentService() {
		super("GcmIntentService");
	}

	public static final String TAG = "GCM Demo";

	@Override
	protected void onHandleIntent(Intent intent) {
		Bundle extras = intent.getExtras();
		GoogleCloudMessaging gcm = GoogleCloudMessaging.getInstance(this);
		// The getMessageType() intent parameter must be the intent you received
		// in your BroadcastReceiver.
		String messageType = gcm.getMessageType(intent);

		if (!extras.isEmpty()) { // has effect of unparcelling Bundle
			/*
			 * Filter messages based on message type. Since it is likely that GCM will be extended in the future with new message types, just ignore any message types you're not interested in, or that
			 * you don't recognize.
			 */
			if (GoogleCloudMessaging.MESSAGE_TYPE_SEND_ERROR.equals(messageType)) {
				sendNotification("Send error: " + extras.toString());
			} else if (GoogleCloudMessaging.MESSAGE_TYPE_DELETED.equals(messageType)) {
				sendNotification("Deleted messages on server: " + extras.toString());
				// If it's a regular GCM message, do some work.
			} else if (GoogleCloudMessaging.MESSAGE_TYPE_MESSAGE.equals(messageType)) {
				// This loop represents the service doing some work.
				// for (int i = 0; i < 5; i++) {
				// Log.i(TAG, "Working... " + (i + 1) + "/5 @ " + SystemClock.elapsedRealtime());
				// try {
				// Thread.sleep(5000);
				// } catch (InterruptedException e) {
				// }
				// }
				Log.i(TAG, "Completed work @ " + SystemClock.elapsedRealtime());
				try {
					JSONObject jsonObj = new JSONObject(extras.getString(Constants.EXTRA_MESSAGE)).getJSONObject("data");
					mUserId = jsonObj.getString(Constants.USER_ID);
					mUserRequestId = jsonObj.getString(Constants.USER_REQUEST_ID);
					mId_request = jsonObj.getString(Constants.ID_REQUEST);
				} catch (JSONException e) {
					e.printStackTrace();
				}
				
				Log.e(TAG, " " + mUserId + " " + mUserRequestId + " "+ mId_request);
				new GetDataFriendRequest().execute(mUserId);
				// Post notification of received message.
				sendNotification("Received: " + extras.getString(Constants.EXTRA_MESSAGE));
				Log.i(TAG, "Received: " + extras.getString(Constants.EXTRA_MESSAGE));
				
			}
		}
		// Release the wake lock provided by the WakefulBroadcastReceiver.
		GcmBroadcastReceiver.completeWakefulIntent(intent);
	}

	// Put the message into a notification and post it.
	// This is just one simple example of what you might choose to do with
	// a GCM message.
	private void sendNotification(String msg) {
		mNotificationManager = (NotificationManager) this.getSystemService(Context.NOTIFICATION_SERVICE);

		PendingIntent contentIntent = PendingIntent.getActivity(this, 0, new Intent(this, ActivityRegister.class), 0);

		NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(this).setSmallIcon(R.drawable.ic_launcher).setContentTitle("GCM Notification")
				.setStyle(new NotificationCompat.BigTextStyle().bigText(msg)).setContentText(msg);

		mBuilder.setContentIntent(contentIntent);
		mNotificationManager.notify(NOTIFICATION_ID, mBuilder.build());
	}

	private JSONObject getDataByUserIdOnServer(String userId) {
		List<NameValuePair> params = new ArrayList<NameValuePair>();
		params.add(new BasicNameValuePair(Constants.USER_ID, userId));

		HttpRequest request = new HttpRequest();
		String result = request.makeServiceCall(Constants.URL_GET_DATA_BY_USER_ID, HttpRequest.POST, params);
		if (!result.isEmpty()) {
			try {
				JSONObject jsonObj = new JSONObject(result);
				return jsonObj;
			} catch (JSONException e) {
				e.printStackTrace();
			}
		}
		return null;
	}

	private boolean insertRequestFriendToDb(JSONObject jsonObj, String userId, String id_request) {
		DatabaseHanler db = new DatabaseHanler(this);

		try {
			JSONObject data = jsonObj.getJSONObject("data");
			String friend_id = data.getString(Constants.USER_ID);
			String friend_name = data.getString(Constants.USERNAME);
			String friend_avatar = data.getString(Constants.AVATAR);
			String friend_phone = data.getString(Constants.PHONE_NUMBER);
			Log.i(TAG, friend_id);
			DatabaseFriend df = new DatabaseFriend(Integer.parseInt(userId), Integer.parseInt(friend_id), friend_name, friend_avatar, "", friend_phone, "", Integer.parseInt(id_request));
			db.insertDatabaseFriend(df);
			return true;
		} catch (JSONException e) {
			e.printStackTrace();
		}
		return false;
	}

	// Inner class
	class GetDataFriendRequest extends AsyncTask<String, Void, JSONObject> {

		@Override
		protected JSONObject doInBackground(String... params) {
			JSONObject jsonObj = getDataByUserIdOnServer(params[0]);
			return (jsonObj == null) ? null : jsonObj;
		}

		@Override
		protected void onPostExecute(JSONObject result) {
			if (result != null) {
				if (insertRequestFriendToDb(result, mUserRequestId, mId_request)) {
					Log.i(TAG, "Insert friend request successfully!");
				} else {
					Log.i(TAG, "Insert friend request failure!");
				}
			} else {
				Log.i(TAG, "Get data failure!");
			}
		}
	}
}